package com.zhijian.medical.enums.diagnose.report;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 原发性肝癌报告枚举
 */
@Slf4j
public class LiverEnum {

    /**
     * 术前辅助治疗
     */
    @AllArgsConstructor
    @Getter
    public enum PreoperativeAdjuvantTherapyEnum {

        NO("yes", "有"),
        NEW("no", "无"),
        UNKNOWN("unknown", "未知");

        private final String key;
        private final String desc;


        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PreoperativeAdjuvantTherapyEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 标本名称
     */
    @AllArgsConstructor
    @Getter
    public enum SampleNameEnum {

        // 左半肝切除标本 右半肝切除标本 部分肝脏切除标本 肝移植全肝切除标本 其他
        LEFT_HALF("left_half", "左半肝切除标本"),
        RIGHT_HALF("right_half", "右半肝切除标本"),
        PARTIAL("partial", "部分肝脏切除标本"),
        HEART_TRANSPLANT("heart_transplant", "肝移植全肝切除标本"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肿瘤部位
     */
    @AllArgsConstructor
    @Getter
    public enum TumorLocationEnum {

        //肝左叶 肝右叶 尾状叶 全肝 肝中叶 未知 S1 S2 S3 S4 S5 S6 S7 S8
        LEFT_HEMI("heli", "肝左叶"),
        RIGHT_HEMI("heri", "肝右叶"),
        TAIL_HEMI("helt", "尾状叶"),
        ALL_HEMI("hela", "全肝"),
        MIDDLE_HEMI("helm", "肝中叶"),
        UNKNOWN("unknown", "未知"),
        S1("S1", "S1"),
        S2("S2", "S2"),
        S3("S3", "S3"),
        S4("S4", "S4"),
        S5("S5", "S5"),
        S6("S6", "S6"),
        S7("S7", "S7"),
        S8("S8", "S8");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorLocationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 肿瘤大小
     */
    @AllArgsConstructor
    @Getter
    public enum TumorSizeEnum {

        S3("3.5x2.0", "3.5x2.0"),
        S20("20x16x3", "20x16x3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorSizeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 巨检分型
     */
    @AllArgsConstructor
    @Getter
    public enum MacroscopicClassificationEnum {
        // 肝細胞癌 肝内胆管癌
        GENERAL("general", "肝細胞癌", MacroscopicClassificationGeneralEnum.getList()),
        GENITOURINARY("genitourinary", "肝内胆管癌", MacroscopicClassificationGenitourinaryEnum.getList()),
        OTHER("other", "其他", MacroscopicClassificationOtherEnum.getList());


        private final String key;
        private final String desc;
        private final List<MappingEnum<String, String>> child;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MacroscopicClassificationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), e.getChild()))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 巨检分型-肝細胞癌
     */
    @AllArgsConstructor
    @Getter
    public enum MacroscopicClassificationGeneralEnum {
        //单结节型有包膜 单结节型无包膜 多结节型 巨块型 弥漫型
        SINGLE_NODULE_WITH_MEMBRANE("single_nodule_with_membrane", "单结节型有包膜"),
        SINGLE_NODULE_WITHOUT_MEMBRANE("single_nodule_without_membrane", "单结节型无包膜"),
        MULTIPLE_NODULES("multiple_nodules", "多结节型"),
        GIGANTIC_NODULE("gigantic_nodule", "巨块型"),
        SPREADING_NODULE("spreading_nodule", "弥漫型");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MacroscopicClassificationGeneralEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 巨检分型-肝内胆管癌
     */
    @AllArgsConstructor
    @Getter
    public enum MacroscopicClassificationGenitourinaryEnum {
        // 肿块型（MF）管周浸润型（PI） 管内生长型（IG） 混合型（PI+MF）
        MASS("mass", "肿块型（MF）"),
        PIPE_INFILTRATION("pipe_infiltration", "管周浸润型（PI）"),
        GROWTH_IN_THE_INNER_TUBE("growth_in_the_inner_tube", "管内生长型（IG）"),
        MIXED("mixed", "混合型（PI+MF）");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MacroscopicClassificationGenitourinaryEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 巨检分型-其他
     */
    @AllArgsConstructor
    @Getter
    public enum MacroscopicClassificationOtherEnum {
        // 其他
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MacroscopicClassificationOtherEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 病理诊断
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalDiagnosisEnum {

        // 肝细胞癌 双表型肝细胞癌 肝内胆管癌 混合型肝细胞癌-胆管癌 肝母细胞瘤 末分化癌，NOS
        HEPATOCLLAEMIA("hepatocelluloma", "肝细胞癌"),
        DUAL_PHENOTYPE_LIVER_CELLS("dual_phenotype_liver_cells", "双表型肝细胞癌"),
        INTRAHEPATIC_BILE_DUCT("intrahepatic_bile_duct", "肝内胆管癌"),
        MIXED_HEPATOCLLAEMIA_GENITOURINARY_CANCER("mixed_hepatocelluloma_genitourinary_cancer", "混合型肝细胞癌-胆管癌"),
        HEPATOBLASTOMA("hepatoblastoma", "肝母细胞瘤"),
        UNDIFFERENTIATED("undifferentiated", "末分化癌，NOS");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalDiagnosisEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 组织学亚型
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalSubtypeEnum {
        //肝细胞癌 肝内胆管癌
        HEPATOCYTE("hepatocyte", "肝细胞癌", HistologicalSubtypeHepatocyteEnum.getList()),
        INTRAHEPATIC_BILE_DUCT("intrahepatic_bile_duct", "肝内胆管癌", HistologicalSubtypeIntrahepaticNBileDuctEnum.getList());

        private final String key;
        private final String desc;
        private final List<MappingEnum<String, String>> child;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalSubtypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), e.getChild()))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学亚型-肝细胞癌
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalSubtypeHepatocyteEnum {
        //梁型 假腺样型 实体型 硬化型 紫癜型 菊形团型 纤维板层型 透明细胞型 脂肪肝型 富于中性粒细胞型 富于淋巴细胞型
        LONG_AXIAL_TYPE("long_axial_type", "梁型"),
        PSEUDOGLANDULAR_TYPE("pseudoglandular_type", "假腺样型"),
        ENTITY_TYPE("entity_type", "实体型"),
        HARDENED_TYPE("hardened_type", "硬化型"),
        PURPURA_TYPE("purpura_type", "紫癜型"),
        CHRYSANTHEMUM_SHAPED_CLUSTER("chrysanthemum_shaped_cluster", "菊形团型"),
        FIBER_BOARD_LAYER_TYPE("fiber_board_layer_type", "纤维板层型"),
        TRANSPARENT_CELL_TYPE("transparent_cell_type", "透明细胞型"),
        FATTY_LIVER_TYPE("fatty_liver_type", "脂肪肝型"),
        ENRICHED_NEUTROPHIL_TYPE("enriched_neutrophil_type", "富于中性粒细胞型"),
        ENRICHED_LYMPHOCYTE_TYPE("enriched_lymphocyte_type", "富于淋巴细胞型");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalSubtypeHepatocyteEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学亚型-肝内胆管癌
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalSubtypeIntrahepaticNBileDuctEnum {
        //大胆管型  小胆管型 细胆管型 腺鳞癌 印戒细胞癌 透明细胞癌 粘液表皮样癌 淋巴上皮瘤样型 肉瘤样型
        BIG_BILIARY("big_biliary", "大胆管型"),
        SMALL_BILIARY("small_biliary", "小胆管型"),
        FINE_BILIARY("fine_biliary", "细胆管型"),
        ADENOCARCINOMA("adenocarcinoma", "腺鳞癌"),
        SIGNET_RING_CELL("signet_ring_cell", "印戒细胞癌"),
        TRANSPARENT_CELL("transparent_cell", "透明细胞癌"),
        MUCOEPIDERMAL("mucoepidermoidal", "粘液表皮样癌"),
        LYMPHOEPITHELIAL("lymphoepithelial", "淋巴上皮瘤样型"),
        SQUAMOUS("squamous", "肉瘤样型");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalSubtypeIntrahepaticNBileDuctEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 分化程度
     */
    @AllArgsConstructor
    @Getter
    public enum DifferentiationDegreeEnum {

        //高分化 中分化 低分化 高-中分化 中-低分化 未分化
        HIGH("high", "高分化"),
        MIDDLE("middle", "中分化"),
        LOW("low", "低分化"),
        HIGH_MIDDLE("high_middle", "高-中分化"),
        MIDDLE_LOW("middle_low", "中-低分化"),
        UNDIFFERENTIATED("undifferentiated", "未分化");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(DifferentiationDegreeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 坏死
     */
    @AllArgsConstructor
    @Getter
    public enum NecrosisEnum {
        //多量坏死 中量坏死 少量坏死 无坏死
        MUCH("much", "多量坏死"),
        MIDDLE("middle", "中量坏死"),
        LITTLE("little", "少量坏死"),
        NO("no", "无坏死");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NecrosisEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 卫星灶
     */
    @AllArgsConstructor
    @Getter
    public enum SatelliteNoduleEnum {
        //有，1个 有，2个 有，多于2个 无 无法确定
        ONE("one","有，1个"),
        TWO("two","有，2个"),
        MORE("more","有，多于2个"),
        NO("no","无"),
        UNDETERMINED("undetermined","无法确定");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SatelliteNoduleEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }


    /**
     * 大血管癌栓
     */
    @AllArgsConstructor
    @Getter
    public enum LargeVesselCancerThrombusEnum {
        //见癌栓 末见癌栓 可疑 无法评估
        SEE_CANCER_THROMBUS("see_cancer_thrombus", "见癌栓"),
        NO_CANCER_THROMBUS("no_cancer_thrombus", "末见癌栓"),
        SUSPECT("suspect", "可疑"),
        UNDETERMINED("undetermined", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LargeVesselCancerThrombusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 胆管癌栓
     */
    @AllArgsConstructor
    @Getter
    public enum BileDuctCancerThrombusEnum {
        //见癌栓 末见癌栓 可疑 无法评估
        SEE_CANCER_THROMBUS("see_cancer_thrombus", "见癌栓"),
        NO_CANCER_THROMBUS("no_cancer_thrombus", "末见癌栓"),
        SUSPECT("suspect", "可疑"),
        UNDETERMINED("undetermined", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(BileDuctCancerThrombusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 神经侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NeurologicalInvasionEnum {

        NOT_YET_SEEN("not_yet_seen", "未见侵犯"),
        VISIBLE("visible", "见侵犯"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeurologicalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肝被膜侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum LiverCapsuleInvasionEnum {
        //未累及肝被膜 累及但未穿透肝被膜 穿透肝被膜 无法评估
        NOT_INJURED("not_injured", "未累及肝被膜"),
        INJURED("injured", "累及但未穿透肝被膜"),
        PENETRATED("penetrated", "穿透肝被膜"),
        UNDETERMINED("undetermined", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LiverCapsuleInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肝外脏器或结构侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum ExternalOrgansOrStructuresInvasionEnum {
        VISIBLE("visible", "见侵犯"),
        NOT_YET_SEEN("not_yet_seen", "未见侵犯"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeurologicalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 切缘名称
     */
    @AllArgsConstructor
    @Getter
    public enum EdgeNameEnum {
        //肝脏断端切缘 胆管切缘 其他
        LIVER("liver", "肝脏断端切缘"),
        BILE_DUCT("bile_duct", "胆管切缘"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(EdgeNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 切缘情况
     */
    @AllArgsConstructor
    @Getter
    public enum EdgeSituationEnum {
        //见癌 未见癌 癌组织紧靠切缘 灶性区见癌组织累及 紧靠但未累及 情况无法评估
        SEE_CANCER("see_cancer", "见癌"),
        NOT_SEE_CANCER("not_see_cancer", "未见癌"),
        CANCER_TIGHTLY_NEAR_THE_EDGE("cancer_tightly_near_the_edge", "癌组织紧靠切缘"),
        CANCER_IN_THE_FOCUS("cancer_in_the_focus", "灶性区见癌组织累及"),
        TIGHTLY_NEAR_THE_EDGE("tightly_near_the_edge", "紧靠但未累及"),
        UNDETERMINED("undetermined", "情况无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(EdgeSituationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 周围肝脂肪变性（F）
     */
    @AllArgsConstructor
    @Getter
    public enum PeripheralLiverFatDegenerationEnum {
        //F0 F1 F2 F3 F4
        F0("f0", "F0"),
        F1("f1", "F1"),
        F2("f2", "F2"),
        F3("f3", "F3"),
        F4("f4", "F4");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PeripheralLiverFatDegenerationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 炎症（G）
     */
    @AllArgsConstructor
    @Getter
    public enum InflammationEnum {
        //G0 G1 G2 G3 G4
        G0("g0", "G0"),
        G1("g1", "G1"),
        G2("g2", "G2"),
        G3("g3", "G3"),
        G4("g4", "G4");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InflammationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 纤维化分期（S）
     */
    @AllArgsConstructor
    @Getter
    public enum FibrosisStageEnum {
        //S0 S1 S2 S3 S4 S5 S6 S7 S8
        S0("s0", "S0"),
        S1("s1", "S1"),
        S2("s2", "S2"),
        S3("s3", "S3"),
        S4("s4", "S4");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(FibrosisStageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 胆囊
     */
    @AllArgsConstructor
    @Getter
    public enum GallbladderEnum {
        //慢性胆囊炎 胆囊结石，慢性胆囊炎 胆固醇性息肉，慢性胆囊炎 胆囊结石，胆固醇性息肉，慢性胆襄炎 慢性胆囊炎，胆囊腺肌病
        CHRONIC_GALLBLADDER_INFLAMMATION("chronic_gallbladder_inflammation", "慢性胆囊炎"),
        CHRONIC_GALLBLADDER_STONE("chronic_gallbladder_stone", "胆囊结石，慢性胆囊炎"),
        CHRONIC_GALLBLADDER_POLYPOID("chronic_gallbladder_polyoid", "胆固醇性息肉，慢性胆囊炎"),
        CHRONIC_GALLBLADDER_STONE_POLYPOID("chronic_gallbladder_stone_polyoid", "胆囊结石，胆固醇性息肉，慢性胆囊炎"),
        CHRONIC_GALLBLADDER_POLYOID_GALLBLADDER_MUSCLE_DISEASE("chronic_gallbladder_polyoid_gallbladder_muscle_disease", "慢性胆囊炎，胆囊腺肌病");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(GallbladderEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 淋巴结
     */
    @AllArgsConstructor
    @Getter
    public enum LymphGlandEnum {

        NOT_TRANSFERRED("not_transferred", "未见转移"),
        SEE_TRANSFER("see_transfer", "见转移"),
        ADIPOSE_TISSUE("adipose_tissue", "脂肪组织"),
        GRANULOMATOUS_INFLAMMATION("granulomatous_inflammation", "肉芽肿性炎"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphGlandEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 远处转移
     */
    @AllArgsConstructor
    @Getter
    public enum RemoteTransferEnum {
        //CM0临床无远处转移 cM1临床有远处转移 pM1病理查有远处转移 Mx未知
        CM0("cm0", "cM0临床无远处转移"),
        CM1("cm1", "cM1临床有远处转移"),
        PM1("pm1", "pM1病理查有远处转移"),
        MX("mx", "Mx未知");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(RemoteTransferEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 免疫组化-表达式
     */
    @AllArgsConstructor
    @Getter
    public enum ImmunohistochemistryExpressionEnum {

        PLUS("+", "+"),
        REDUCE("-", "-"),
        PLUS2("++", "++"),
        PLUS3("+++", "+++"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ImmunohistochemistryExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-其他表达
     */
    @AllArgsConstructor
    @Getter
    public enum ImmunohistochemistryOtherExpressionEnum {

        LYMPHOCYTE_EXPRESSION("lymphocyte_expression", "淋巴细胞表达"),
        VASCULAR_EXPRESSION("vascular_expression", "脉管表达"),
        IMMUNE_CELL_EXPRESSION("immune_cell_expression", "间质免疫细胞表达");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ImmunohistochemistryOtherExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 特殊染色-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum SpecialEnum {

        REDUCE("-", "-"),
        PLUS("+", "+");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SpecialEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原位杂交/特殊染色-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum InSituHybridizationExpressionEnum {

        PLUS("+", "+"),
        REDUCE("-", "-"),
        ZERO("0", "0"),
        PLUS1("1+", "1+"),
        PLUS2("2+", "2+"),
        PLUS3("3+", "3+"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituHybridizationExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 其他送检组织
     */
    @AllArgsConstructor
    @Getter
    public enum OtherInspectionOrganizationsEnum {

        GASTRIC_TISSUE("gastric_tissue", "胃组织"),
        ANASTOMOTIC_SITE_NEAR_END("anastomotic_site_near_end", "吻合口近端"),
        ANASTOMOTIC_SITE_REMOTE_END("anastomotic_site_remote_end", "吻合口远端");

        private final String key;
        private final String desc;


        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherInspectionOrganizationsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }
}
